package com.example.ziliao.utils

import kotlin.math.floor
import kotlin.math.log10
import kotlin.math.pow
import kotlin.random.Random

object OptionGenerator {
    fun generateRangeOptions(value: Double): List<Pair<String, Boolean>> {
        val options = mutableListOf<Pair<String, Boolean>>()
        
        // 计算范围
        val (lowerBound, upperBound) = calculateRange(value)
        val range = upperBound - lowerBound
        val correctLower = lowerBound
        val correctUpper = upperBound

        // 随机选择一种选项组合（0-3）
        val optionType = Random.nextInt(4)
        
        // 根据选项类型生成不同的选项组合
        when (optionType) {
            0 -> {
                // 正确答案在D选项
                val a = correctLower - 2 * range
                val b = correctLower - range
                val c = correctLower
                options.add("不到${formatRangeNumber(a)}" to false)
                options.add("${formatRangeNumber(a)}-${formatRangeNumber(b)}" to false)
                options.add("${formatRangeNumber(b)}-${formatRangeNumber(c)}" to false)
                options.add("超过${formatRangeNumber(c)}" to true)
            }
            1 -> {
                // 正确答案在C选项
                val a = correctLower - range
                val b = correctLower
                val c = correctUpper
                options.add("不到${formatRangeNumber(a)}" to false)
                options.add("${formatRangeNumber(a)}-${formatRangeNumber(b)}" to false)
                options.add("${formatRangeNumber(b)}-${formatRangeNumber(c)}" to true)
                options.add("超过${formatRangeNumber(c)}" to false)
            }
            2 -> {
                // 正确答案在B选项
                val a = correctLower
                val b = correctUpper
                val c = correctUpper + range
                options.add("不到${formatRangeNumber(a)}" to false)
                options.add("${formatRangeNumber(a)}-${formatRangeNumber(b)}" to true)
                options.add("${formatRangeNumber(b)}-${formatRangeNumber(c)}" to false)
                options.add("超过${formatRangeNumber(c)}" to false)
            }
            3 -> {
                // 正确答案在A选项
                val a = correctUpper
                val b = correctUpper + range
                val c = correctUpper + 2 * range
                options.add("不到${formatRangeNumber(a)}" to true)
                options.add("${formatRangeNumber(a)}-${formatRangeNumber(b)}" to false)
                options.add("${formatRangeNumber(b)}-${formatRangeNumber(c)}" to false)
                options.add("超过${formatRangeNumber(c)}" to false)
            }
        }

        return options
    }

    fun generateValueOptions(value: Double): List<Pair<String, Boolean>> {
        val options = mutableListOf<Pair<String, Boolean>>()
        
        // 正确答案
        options.add(formatNumber(value) to true)
        
        // 迷惑项1：使用正确答案的0.8-1.2倍
        val option1 = value * Random.nextDouble(0.8, 1.2)
        options.add(formatNumber(option1) to false)
        
        // 迷惑项2：使用正确答案的0.6-0.7倍或1.3-1.4倍
        val option2 = if (Random.nextBoolean()) {
            value * Random.nextDouble(0.6, 0.7)
        } else {
            value * Random.nextDouble(1.3, 1.4)
        }
        options.add(formatNumber(option2) to false)
        
        // 迷惑项3：使用正确答案的0.4-0.5倍或1.5-1.6倍
        val option3 = if (Random.nextBoolean()) {
            value * Random.nextDouble(0.4, 0.5)
        } else {
            value * Random.nextDouble(1.5, 1.6)
        }
        options.add(formatNumber(option3) to false)
        
        return options
    }

    fun calculateRange(value: Double): Pair<Int, Int> {
        // 计算数量级（比如1949.49的数量级是100）
        val magnitude = 10.0.pow(floor(log10(value) - 1))
        // 获取前两位数字（1949.49 -> 19）
        val firstTwoDigits = (value / magnitude).toInt()
        // 计算范围
        val lowerBound = (firstTwoDigits * magnitude).toInt()
        val upperBound = ((firstTwoDigits + 1) * magnitude).toInt()
        return Pair(lowerBound, upperBound)
    }

    fun formatRangeNumber(number: Int): String {
        return when {
            number >= 10000000 -> {
                // 千万级别
                String.format("%.1f千万", number / 10000000.0)
            }
            number >= 10000 -> {
                // 万级别
                if (number % 10000 == 0) {
                    "${number / 10000}万"
                } else {
                    String.format("%.1f万", number / 10000.0)
                }
            }
            else -> number.toString()
        }
    }

    fun formatNumber(number: Double): String {
        return when {
            number < 1000 -> {
                // 小于1000的数随机显示一位或两位小数
                when (Random.nextInt(2)) {
                    0 -> String.format("%.1f", number) // 一位小数
                    else -> String.format("%.2f", number) // 两位小数
                }
            }
            else -> String.format("%.0f", number) // 大于等于1000的数显示为整数
        }
    }
} 